home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 1996 September & October / Amiga-CD 1996 #9-10.iso / demos / storm-c / stormwizard / example-source / c-source / simple / basis / basis.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-18  |  4.3 KB  |  170 lines
  1. /* Standard Rumpfprogramm.
  2.  
  3.    Dieser Quellcode ist der Anfang aller mit StormWizard-Oberflächen
  4.    versehenen Programmen in C oder C++!
  5.  
  6.    (geschrieben unter StormC V1.1)
  7.  
  8.    $VER:              1.0 (12.06.96)
  9.  
  10.    Autor:             Thomas Mittelsdorf
  11.  
  12.    © 1996 HAAGE & PARTNER Computer GmbH,  All Rights Reserved
  13.  
  14. */
  15.  
  16. #include    <stdio.h>
  17.  
  18. #include    <clib/alib_protos.h>
  19.  
  20. #include    <pragma/exec_lib.h>
  21. #include    <pragma/intuition_lib.h>
  22. #include    <pragma/utility_lib.h>
  23. #include    <pragma/wizard_lib.h>
  24.  
  25. #include    <libraries/wizard.h>
  26. #include    <intuition/gadgetclass.h>
  27. #include    <intuition/intuition.h>
  28.  
  29. #include    "basis.h"
  30.  
  31. APTR    surface;
  32. struct Screen    *screen;
  33. struct NewWindow *newwin;
  34. struct Window    *window;
  35. struct WizardWindowHandle *winhandle;
  36. struct Gadget *gads[WINDOW_MAIN_GADGETS];
  37.  
  38. /* Falls Sie mit einem anderen Entiwcklungssystem als StormC
  39.    arbeiten, müssen zuerst alle Bibliotheken geöffnet und
  40.    am Ende wieder geschlossen werden!
  41. */
  42. #ifndef __STORM__
  43. struct Library *IntuitionBase;
  44. struct Library *WizardBase;
  45.  
  46. int init_libraries( void);
  47. void exit_libraries( void);
  48. #endif
  49. /*
  50.  
  51. */
  52.  
  53. void main( void)
  54. {
  55.     BOOL Flag;
  56.     struct IntuiMessage *msg;
  57.  
  58.     #ifndef __STORM__
  59.     if(! init_libraries( )) // Nur aufrufen, wenn nicht mit StormC kompiliert wird!
  60.         return;                             // Fehler beim Öffnen
  61.     #endif
  62.  
  63.  
  64.     // Oberflächenbeschreibung laden!
  65.     if ((surface=WZ_OpenSurface("basis.wizard",0L,TAG_DONE)))
  66.     {
  67.  
  68.         // Natürlich brauchen wir auch einen Screen.
  69.         if ((screen=LockPubScreen( 0L)))
  70.         {
  71.  
  72.             // Jetzt reservieren wor ein WindowHandle, mit dem unsere Objekte
  73.             // durch die wizard.library verwaltet werden.
  74.             if ((winhandle=WZ_AllocWindowHandle(screen,0L,surface,TAG_DONE)))
  75.             {
  76.  
  77.                 // Da ein WindowHandle nur Sinn macht, wenn auch die Objekte
  78.                 // darin vorkommen, legen wir diese Objekte jetzt an.
  79.                 if ((newwin=WZ_CreateWindowObj(winhandle,WINDOW_MAIN,WWH_GadgetArray,gads,
  80.                                                                             WWH_GadgetArraySize,sizeof(gads),
  81.                                                                             TAG_DONE)))
  82.                 {
  83.  
  84.                     // Nachdem das glatt ging, versuchen wir unser
  85.                     // Fenster zu öffnen. Dabei werden alle Objekte installiert.
  86.                     if ((window=WZ_OpenWindow(winhandle,newwin,WA_AutoAdjust,TRUE,
  87.                                                                             TAG_DONE)))
  88.                     {
  89.                         Flag=TRUE;    // Flag zum Beenden der nachfolgenden Schleife
  90.  
  91.                         do
  92.                         {
  93.                             // Da wir keine Rechenzeit verschwenden wollen, wird
  94.                             // das Program solange "schlafen" legen bis eine Nachricht
  95.                             // eintifft. Selbstverständlich kann auch Wait() verwendet
  96.                             // werden kann.
  97.                             WaitPort(window->UserPort);
  98.  
  99.                             if ((msg=(struct IntuiMessage *)GetMsg(window->UserPort)))
  100.                             {
  101.                                 // Ha, da ist doch tatsächlich eine Message ange-
  102.                                 // kommen. Na dann gucken wir mal ob Sie auch vom
  103.                                 // richtigen Type ist.
  104.  
  105.                                 switch(msg->Class)
  106.                                 {
  107.                                     case IDCMP_CLOSEWINDOW:
  108.                                         {
  109.                                             Flag=FALSE;
  110.                                         }
  111.                                         break;
  112.                                 }
  113.  
  114.                                 // Da wir keine Speicherleichen dulden und
  115.                                 // das Nachrichtensystem nicht durcheinander bringen
  116.                                 // wollen, teilen wir den Betriebssystem mit, das
  117.                                 // die Nachricht von uns nicht mehr benötigt wird.
  118.                                 ReplyMsg((struct Message *)msg);
  119.                             }
  120.                         }
  121.                         while (Flag);
  122.  
  123.                         // Fenster schließen
  124.                         WZ_CloseWindow(winhandle);
  125.                     }
  126.                 }
  127.  
  128.                 // In jedem Fall muß ein mit WZ_AllocWindowHandle() angelegter
  129.                 // WindowHandle auch wieder freigegeben werden. Übrigens
  130.                 // kann das Fenster hierbei noch offen sein. Probieren Sie es!
  131.                 WZ_FreeWindowHandle(winhandle);
  132.             }
  133.  
  134.             // PublicScreen-Benutzerzähler wieder um eins verringern
  135.             UnlockPubScreen(0L,screen);
  136.         }
  137.  
  138.         // Da wir keine Objekte von dieser Oberfläche mehr besitzen und wir diese
  139.         // auch nicht mehr anlegen, geben wir sie einfach frei. Übrigens noch
  140.         // nicht freigegebene WindowHandles werden hierbei von der
  141.         // wizard.library entfernt. Noch geöffnete Fenster werden dabei auch
  142.         // geschlossen.
  143.         WZ_CloseSurface(surface);
  144.     }
  145.     #ifndef __STORM__
  146.     exit_libraries(); // Nur aufrufen, wenn nicht mit StormC kompiliert wird!
  147.     #endif
  148. }
  149.  
  150. #ifndef __STORM__
  151. int init_libraries( void)
  152. {
  153.  
  154. if(! (IntuitionBase = (struct Library *)OpenLibrary("intuition.library",37L)))
  155.     return 0;
  156.  
  157. if(! (WizardBase = (struct Library *)OpenLibrary("wizard.library",37L)))
  158.     return 0;
  159.  
  160. return 1;
  161. }
  162.  
  163. void exit_libraries( void)
  164. {
  165.  
  166. CloseLibrary((struct Library *) WizardBase);
  167. CloseLibrary((struct Library *) IntuitionBase);
  168. }
  169. #endif
  170.